home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 2000 February / Macworld (2000-02).dmg / Updaters / WhiteCap 3.2.2.sea / WhiteCap 3.2.2 / WhiteCap Source / WhiteCap.cpp < prev    next >
C/C++ Source or Header  |  1999-10-29  |  24KB  |  1,067 lines
  1. #include "WhiteCap.h"
  2.  
  3. #include "EgOSUtils.h"
  4.  
  5. #if EG_MAC
  6. #include <Menus.h>
  7. #include <Windows.h>
  8. #include <Palettes.h>
  9.  
  10. #if MACAMP
  11. #include "MacAMP_Visual.h"
  12. extern VPInfoBlock gPlugInfo;
  13. #endif
  14.  
  15.  
  16. #if SOUNDJAM
  17. #include "VisFramework.h"
  18. #endif
  19.  
  20.  
  21. #include "CEgFileSpec.h"
  22. #include "Sample.h"
  23. #include "CEgIOFile.h"
  24.  
  25.  
  26. #define __setupPort        GDHandle        saveDev;                                \
  27.                          GrafPtr            savePort;                                \
  28.                         ::GetGWorld( (GWorldPtr*)(&savePort), &saveDev );        \
  29.                         ::SetPort( mOSPort );                
  30.  
  31.  
  32. #define __restorePort     ::SetGWorld( (GWorldPtr)(savePort), saveDev );            
  33. #endif
  34.  
  35. #if EG_WIN
  36. #define __setupPort
  37. #define __restorePort 
  38. #include "RectUtils.h"
  39.  
  40. #include "vis.h"
  41. extern winampVisModule gWCModule;
  42.  
  43. #endif
  44.  
  45.  
  46.  
  47.  
  48. WhiteCap::WhiteCap( CEgFileSpec& inPluginsFolder, void* inRefCon ) :
  49.     mPrefs( "WhiteCap Preferences", true ),
  50.     mConfigs( cNoDuplicates_CaseInsensitive, cSortLowToHigh) {
  51.     CEgFileSpec spec;
  52.     UtilStr name, str;
  53.     
  54.     
  55.     mPrefs.Load();
  56.     if ( mPrefs.GetPref( 'Vers' ) != WHITECAP_COMPAT_VERSION ) {
  57.         mMagScale             = 1;
  58.         mTransitionLo        = 5;
  59.         mTransitionHi        = 22;
  60.         mSlideShowInterval    = 15000;        // Factory: 15 secs per config
  61.         mScrnSaverDelay        = -1 * 60000.0;    // Factory: screen saver mode disabled
  62.         mPrefs.SetPref( 'Vers', WHITECAP_COMPAT_VERSION );
  63.         mShwT_Pref            = 0x3;
  64.         mBorderlessWind        = 0;
  65.         mHandleKeys            = 1;
  66.         mCaptureMode        = 0;
  67.         }
  68.     else {
  69.         mMagScale            = mPrefs.GetPref( 'MScl' ) / 1000.0;
  70.         mTransitionLo        = mPrefs.GetPref( 'TrLo' );
  71.         mTransitionHi        = mPrefs.GetPref( 'TrHi' );
  72.         mSlideShowInterval    = mPrefs.GetPref( 'Slde' ) * 1000.0;
  73.         mScrnSaverDelay        = mPrefs.GetPref( 'SSvr' ) * 1000.0 * 60.0;
  74.         mShwT_Pref            = mPrefs.GetPref( 'ShwT' );
  75.         mBorderlessWind        = mPrefs.GetPref( 'NoBo' );
  76.         mHandleKeys            = mPrefs.GetPref( 'Kybd' );
  77.         mCaptureMode        = 0; //mPrefs.GetPref( 'Capt' );
  78.     }
  79.     
  80.     mRefCon                = inRefCon;
  81.     mInSlideShowMode    = true;
  82.     mAtFullScreen        = false;
  83.     mOSPort                = NULL;
  84.     mNumWorlds            = 0;
  85.     mFrameCount            = 0;
  86.     mFrameCountStart    =
  87.     mLastKeyPollTime    =
  88.     mLastActiveTime     =
  89.     mLastRecordTime        = EgOSUtils::CurTimeMS();
  90.     mCurConfigNum        = -1;
  91.     mNextShapeChange    = 0x7FFFFFFF;
  92.     mFramesPer10Secs    = 400;
  93.     mDoingSetPortWin    = false;
  94.     mMouseWillAwaken    = false;
  95.     mBltEntireWindow    = false;
  96.  
  97.     // Make the first slide show happen quickly
  98.     if ( mSlideShowInterval > 0 ) 
  99.         mNextShapeChange = mFrameCountStart + 10000;
  100.  
  101.     BuildConfigList( inPluginsFolder );
  102.     
  103.     #if EG_MAC
  104.     
  105.     // If ctrl and option key held down, enter capture mode...
  106.     //mCaptureMode = true;
  107.     #endif
  108.     
  109.     // Create capture data path if we're in capture mode
  110.     if ( mCaptureMode ) {
  111.         spec.AssignPathName( "WhiteCap Capture"  );
  112.         spec.SetType( cWC_CaptureType );
  113.         mDumpFile.open( &spec );
  114.         mDumpFile.PutLong( cWhiteCapID );
  115.         mDumpFile.PutLong( WHITECAP_COMPAT_VERSION );
  116.         mDumpFile.PutLong( NUM_SAMPLE_BINS );
  117.     }
  118.     
  119.     for ( int i = 0; i < NUM_SAMPLE_BINS; i++ )
  120.         mSample[ i ] = 0;
  121. }
  122.  
  123.  
  124.  
  125.  
  126. WhiteCap::~WhiteCap() {
  127.  
  128.  
  129.     SetFullScreen( false );
  130.             
  131.     // Rewrite the prefs to disk...
  132.     mPrefs.SetPref( 'Slde', mSlideShowInterval / 1000.0 );
  133.     mPrefs.SetPref( 'SSvr', mScrnSaverDelay / 60000.0 );
  134.     mPrefs.SetPref( 'TrHi', mTransitionHi );
  135.     mPrefs.SetPref( 'TrLo', mTransitionLo );
  136.     mPrefs.SetPref( 'MScl', mMagScale * 1000 );
  137.     mPrefs.SetPref( 'ShwT', mShwT_Pref );
  138.     mPrefs.SetPref( 'NoBo', mBorderlessWind );
  139.     mPrefs.SetPref( 'Kybd', mHandleKeys    );
  140.     mPrefs.SetPref( 'Capt', mCaptureMode );
  141.     
  142.     #if MACAMP || WINAMP
  143.     Rect r;
  144.     #if MACAMP
  145.     GetWinRect( r );
  146.     #else
  147.     // Very annoying:  in Win32, the call to GetWindowRect() is returning garbage in ~WhiteCap(), so just 
  148.     // forget about saving the window position for now in windows :_(
  149.     
  150.     //GetWinRect( r );
  151.     r = mWinRectHolder;  // Just use a recent rect for now
  152.     #endif
  153.     mPrefs.SetPref( 'wTop', r.top );
  154.     mPrefs.SetPref( 'wLft', r.left );
  155.     mPrefs.SetPref( 'wBot', r.bottom );
  156.     mPrefs.SetPref( 'wRgt', r.right );
  157.     #endif
  158.     
  159.     mPrefs.Store();    
  160.     
  161.     
  162.     // Delete all the existing worlds
  163.     for ( int i = 0; i < mNumWorlds; i++ )
  164.         delete mWorld[ i ];
  165. }
  166.  
  167.  
  168.  
  169.  
  170.  
  171. bool WhiteCap::PtInTitle( Point inPt ) {
  172.     int i;
  173.     
  174.     Rect r;
  175.     GetWinRect( r );
  176.     
  177.     inPt.v -= r.top;
  178.     inPt.h -= r.left;
  179.         
  180.     for ( i = 0; i < mNumWorlds; i++ ) {
  181.         if ( ::PtInRect( inPt, &mWorld[ i ] -> mTitleRect ) )
  182.             return true;
  183.     }
  184.         
  185.     return false;
  186. }
  187.  
  188.  
  189.  
  190.  
  191. void WhiteCap::SelectConfig() {
  192.     long i, sel;
  193.     Point pt;
  194.     UtilStr name;
  195.  
  196.     EgOSUtils::GetMouse( pt );
  197.             
  198.     // If we're in full screen mode, show the mouse ptr
  199.     if ( mAtFullScreen )
  200.         EgOSUtils::ShowCursor();
  201.         
  202.     #if EG_MAC
  203.     MenuHandle    menu;
  204.  
  205.     __setupPort
  206.     
  207.     // If we found a world, show a popup menu to select from the configs
  208.     menu = ::NewMenu( 123, "\p " );
  209.     
  210.     // Add the stard slideshow item
  211.     ::AppendMenu( menu, "\p " );
  212.     ::SetMenuItemText( menu, 1, "\p(Start Slide Show)" );
  213.     if ( mInSlideShowMode )
  214.         ::DisableItem( menu, 1 );
  215.  
  216.     for ( i = 1; mConfigs.FetchSpecName( i, name ); i++ ) {
  217.         ::AppendMenu( menu, "\p " );
  218.         ::SetMenuItemText( menu, i + 1, name.getPasStr() );
  219.     }
  220.     ::CheckItem( menu, mCurConfigNum + 1, true ); 
  221.     ::InsertMenu( menu, -1 );
  222.     sel = ::PopUpMenuSelect( menu, pt.v - 6, pt.h, mCurConfigNum + 1 );
  223.     ::DeleteMenu( 123 );
  224.     ::DisposeMenu( menu );
  225.  
  226.     sel = ( sel & 0xFFFF0000 ) ? (sel & 0xFFFF) : 0;
  227.     #endif
  228.     
  229.     
  230.     #if EG_WIN
  231.     long flags;
  232.     
  233.     HMENU myMenu = ::CreatePopupMenu();
  234.     
  235.     // Add item to start slideshow
  236.     flags = MF_STRING;
  237.     if ( mInSlideShowMode )
  238.         flags |= MF_GRAYED;
  239.     else
  240.         flags |= MF_ENABLED;
  241.     ::AppendMenu( myMenu, flags, 1, "(Start Slide Show)" );
  242.     
  243.     for ( i = 1; mConfigs.FetchSpecName( i, name ); i++ ) {
  244.         flags = MF_ENABLED | MF_STRING;
  245.         
  246.         // Split up the menu if it's big...
  247.         if ( i % 35 == 0 )
  248.             flags |= MF_MENUBARBREAK;
  249.         
  250.         // Check the config that's the current/displayed config
  251.         if ( mCurConfigNum == i )
  252.             flags |= MF_CHECKED;
  253.         ::AppendMenu( myMenu, flags, i + 1, name.getCStr() );
  254.     }
  255.     sel = ::TrackPopupMenuEx( myMenu, TPM_RETURNCMD, pt.h, pt.v, mOSPort, NULL );
  256.     ::DestroyMenu( myMenu );
  257.     if ( mAtFullScreen )
  258.         ::SetCapture( mOSPort );
  259.     #endif
  260.     
  261.     if ( sel > 0 ) {
  262.         if ( sel == 1 )
  263.             EnableSlideShow();
  264.         else if ( sel >= 1 ) {
  265.             LoadConfig( sel - 1, EgOSUtils::CurTimeMS() );
  266.             mInSlideShowMode = false;
  267.         }
  268.     }
  269.         
  270.         
  271.     __restorePort
  272. }
  273.  
  274.  
  275.  
  276.  
  277.  
  278. void WhiteCap::EnableSlideShow() {
  279.  
  280.     mInSlideShowMode = true;
  281.     mNextShapeChange = mLastRecordTime;
  282.     mConfigPlayList.Randomize();
  283.  
  284. }
  285.  
  286.  
  287.  
  288.  
  289. void WhiteCap::SetFullScreen( bool inFullScreen ) {
  290.         
  291.         
  292.     // If we're in capture mode, don't allow fullscreen -- it'd be pointless
  293.     if ( mCaptureMode )
  294.         inFullScreen = false;
  295.  
  296.     
  297.     #if SOUNDJAM
  298.     VisHandlerData*    handlerData = (VisHandlerData*) mRefCon;
  299.     if ( handlerData ) {
  300.         if ( mAtFullScreen != inFullScreen ) {
  301.             if ( PlayerSetFullScreen(handlerData->appCookie, handlerData->playerProc, inFullScreen) == noErr)
  302.                 mAtFullScreen = inFullScreen;
  303.         }
  304.     }
  305.     #else
  306.     
  307.     
  308.     bool            ok;    
  309.     int                dispNum;
  310.     Point            size;
  311.  
  312.     if ( inFullScreen && ! mAtFullScreen ) {
  313.         
  314.         if ( PixPort::FullscreenAvail() ) {
  315.  
  316.             __setupPort
  317.             
  318.             // Update the positon of our win 
  319.             GetWinRect( mWinRectHolder );
  320.             dispNum = PixPort::GetOwningDisplay( *((Point*) &mWinRectHolder) );
  321.             
  322.             #if MACAMP
  323.             if ( gPlugInfo.ma -> EnterFullScreen )
  324.                 gPlugInfo.ma -> EnterFullScreen( 'XXXX' /*cPluginAuthor*/, cWhiteCapID );
  325.             ::HideWindow( mOSPort );
  326.             #endif    
  327.  
  328.             #if WINAMP
  329.             ::ShowWindow( gWCModule.hwndParent, SW_HIDE | SW_MINIMIZE );
  330.             #endif
  331.  
  332.                             
  333.             // Put in pref wheather to try 32 before 16 bit color?
  334.             ok = mPort.InitFullscreen( dispNum, size, mOSPort );
  335.             
  336.             if ( ok ) {
  337.  
  338.                 
  339.                 mDispRect.left = 0;
  340.                 mDispRect.top = 0;
  341.                 mDispRect.right = size.h;
  342.                 mDispRect.bottom = size.v;
  343.                 ResizeWorlds();
  344.                 mAtFullScreen = true;
  345.                 mFullscreenStartTime = mLastRecordTime;
  346.                 
  347.                 // If we don't expire them, there'll be an ugly gap for the time it took to go fullscreen
  348.                 for ( int i = 0; i < mNumWorlds; i++ )
  349.                     mWorld[ i ] -> ExpireSamples(); 
  350.                 }    
  351.             else {
  352.                 #if MACAMP
  353.                 if ( gPlugInfo.ma -> ExitFullScreen )
  354.                     gPlugInfo.ma -> ExitFullScreen();
  355.                 ::ShowWindow( mOSPort );
  356.                 #endif
  357.                         
  358.                 #if WINAMP
  359.                 ::ShowWindow( gWCModule.hwndParent, SW_SHOWNORMAL );
  360.                 #endif
  361.             } 
  362.                         
  363.             __restorePort
  364.         } } 
  365.     else if ( ! inFullScreen && mAtFullScreen ) {
  366.  
  367.         #if MACAMP
  368.         if ( gPlugInfo.ma -> ExitFullScreen )
  369.             gPlugInfo.ma -> ExitFullScreen();
  370.         #endif
  371.         
  372.         // Restore the window
  373.         mPort.Deactivate();
  374.         
  375.         __setupPort
  376.  
  377.         SetWinPort( mOSPort, &mWinRectHolder );
  378.         
  379.         __restorePort
  380.         
  381.         mLastMousePt.h -= 55;        
  382.         mAtFullScreen = false;
  383.         
  384.         #if WINAMP
  385.         ::ShowWindow( gWCModule.hwndParent, SW_SHOWNORMAL );
  386.         #endif
  387.     }
  388.     #endif
  389.  
  390.     if ( inFullScreen ) {
  391.     
  392.         // Changing the port (and the resolution) may change the mouse cords
  393.         EgOSUtils::GetMouse( mLastMousePt );
  394.  
  395.         // Default: mouse movement will not exit fullscreen mode
  396.         mMouseWillAwaken = false;    
  397.     }
  398.     
  399.     #if EG_MAC
  400.     ::FlushEvents( 0xFFFF, 0 );
  401.     #endif
  402. }
  403.  
  404.  
  405.  
  406. void WhiteCap::GetWinRect( Rect& outRect ) {
  407.     
  408.     if ( mOSPort ) {
  409.     
  410.         #if EG_MAC
  411.         outRect = (**(((CGrafPtr) mOSPort)->portPixMap)).bounds;
  412.         outRect.left *= -1;
  413.         outRect.top  *= -1;
  414.         outRect.right = outRect.left + mOSPort -> portRect.right;
  415.         outRect.bottom = outRect.top + mOSPort -> portRect.bottom;
  416.         #elif EG_WIN
  417.         RECT wr;
  418.         ::GetWindowRect( mOSPort, &wr );
  419.  
  420.         outRect.left    = wr.left; 
  421.         outRect.top        = wr.top;
  422.         outRect.right    = wr.right; 
  423.         outRect.bottom    = wr.bottom;
  424.         #endif 
  425.         }
  426.     else 
  427.         SetRect( &outRect, 0, 0, 0, 0 );
  428. }
  429.  
  430.  
  431. void WhiteCap::RecordSample( long inCurTime ) {
  432.     
  433.     // Apply the global magnitude scale to the sample/soundbyte
  434.     for ( int i = 0; i < NUM_SAMPLE_BINS; i++ )
  435.         mSample[ i ] *= mMagScale;
  436.     
  437.     // We'll need the 'current' time in Draw()
  438.     mLastRecordTime = inCurTime;
  439.     
  440.     // Give the sample data to the window if we're not in capture mode
  441.     if ( ! mCaptureMode ) {
  442.     
  443.         // Loop thru all the panes in the window
  444.         for ( int i = 0; i < mNumWorlds; i++ ) {
  445.  
  446.             // Tell the world to take a new sound sample (if it wants)
  447.             mWorld[ i ] -> RecordSample( inCurTime, mSample );
  448.         } }
  449.     else {
  450.         mDumpFile.PutByte( CAPTURE_SAMPLE );
  451.         mDumpFile.PutLong( inCurTime );
  452.         mDumpFile.PutBlock( mSample, sizeof( float ) * NUM_SAMPLE_BINS );
  453.     }
  454. }
  455.  
  456.  
  457.  
  458.  
  459. bool WhiteCap::HandleKey( long inChar ) {
  460.     bool handled = false;
  461.     
  462.     if ( mHandleKeys ) {
  463.         if ( inChar >= ' ' && inChar <= '~' ) {
  464.             mKeyBuf.Append( (char) inChar );
  465.             handled = true; }
  466.         else if ( inChar == 128 || inChar == 8 ) {
  467.             mKeyBuf.Keep( mKeyBuf.length() - 1 );
  468.             handled = true;
  469.         }
  470.         mLastKeyTime = mLastRecordTime;
  471.     }
  472.     
  473.     return handled;
  474. }
  475.  
  476.  
  477.  
  478.  
  479.  
  480.  
  481. void WhiteCap::Draw() {
  482.     Rect    r;
  483.     Point    pt;
  484.     long    i, time = mLastRecordTime;
  485.     bool    kybdPress;
  486.     void*    port;
  487.  
  488.  
  489.     // Check key-entered config
  490.     if ( mKeyBuf.length() ) {
  491.     
  492.         // Process the kybd buffer only if we haven't gotten any typing in a while
  493.         if ( time > mLastKeyTime + 2500 ) {
  494.         
  495.             // See if what was types is a command to WhiteCap (vs. a config name to switch to)
  496.             if ( mKeyBuf.compareTo( "slideshow", false ) == 0 ) {
  497.                 if ( mInSlideShowMode )
  498.                     mInSlideShowMode = false;
  499.                 else
  500.                     EnableSlideShow(); }
  501.             else {
  502.                 
  503.                 // Look for a config that best matches what was typed.  Use exact match if user didn't type a lot
  504.                 if ( mKeyBuf.length() >= 4 )
  505.                     i = mConfigs.FetchBestMatch( mKeyBuf ); 
  506.                 else
  507.                     i = mConfigs.Lookup( mKeyBuf );
  508.                     
  509.                 if ( i > 0 ) {
  510.                     LoadConfig( i, mLastRecordTime );
  511.                         
  512.                     // Do a reshuffle if the user changes configs (to avoid repeated patterns)
  513.                     if ( mInSlideShowMode )
  514.                         mConfigPlayList.Randomize();
  515.                 }
  516.             }
  517.             
  518.             mKeyBuf.Wipe();
  519.         }
  520.     }
  521.  
  522.  
  523.     // Load a random waveshape every so often, and randomize things
  524.     if ( time > mNextShapeChange && mInSlideShowMode ) {
  525.     
  526.         // Load the next config in the (randomized) config list...
  527.         i = mConfigPlayList.FindIndexOf( mCurConfigNum );
  528.         
  529.         // Make a new play list if we've reached the end of the list...
  530.         if ( i >= mConfigPlayList.Count() ) {
  531.             mConfigPlayList.Randomize();
  532.             i = 0;
  533.         }
  534.         LoadConfig( mConfigPlayList.Fetch( i + 1 ), mLastRecordTime );
  535.     }
  536.     
  537.     
  538.     // Don't bother doing mouse or kybd poll if sceeen saver mode is disabled
  539.     if ( mScrnSaverDelay > 0 ) {
  540.  
  541.         kybdPress = false;
  542.  
  543.         #if EG_MAC    
  544.         long pollDelay;
  545.         
  546.         // Calc time till next kybd poll (Don't waste valuble time checking the kybd unless we've been idle a while)
  547.         if ( mAtFullScreen )
  548.             pollDelay = 600;
  549.             
  550.         // Don't bother rapildly checking the kybd until we're really close to going into screen saver mode
  551.         else if ( time > mLastActiveTime + mScrnSaverDelay - 90000 )
  552.             pollDelay = ( mLastActiveTime + mScrnSaverDelay - time ) >> 7;
  553.         else
  554.             pollDelay = 10000;
  555.             
  556.         // If it's time to poll the kybd...
  557.         if ( time > mLastKeyPollTime + pollDelay ) {
  558.             ::GetKeys( mCurKeys );
  559.             mLastKeyPollTime = time;
  560.             
  561.             // If the keys are pressed, 'move' the mouse (ie, cause the if-block a few lines from now to 'go'
  562.             if ( ( mCurKeys[0] != mPastKeys[0] ) || 
  563.                  ( mCurKeys[1] != mPastKeys[1] ) || 
  564.                  ( mCurKeys[2] != mPastKeys[2] ) || 
  565.                  ( mCurKeys[3] != mPastKeys[3] ) ) {
  566.                 kybdPress = true;
  567.                 mPastKeys[0] = mCurKeys[0];
  568.                 mPastKeys[1] = mCurKeys[1];
  569.                 mPastKeys[2] = mCurKeys[2];
  570.                 mPastKeys[3] = mCurKeys[3];
  571.             }
  572.         }
  573.         #endif
  574.         
  575.         // Check the mouse pos and record it as active if its been moved.      
  576.         EgOSUtils::GetMouse( pt );
  577.         if ( pt.h != mLastMousePt.h || pt.v != mLastMousePt.v || kybdPress ) {
  578.             mLastMousePt        = pt;
  579.             mLastActiveTime        = time;
  580.             if ( mAtFullScreen && mMouseWillAwaken )
  581.                 SetFullScreen( false ); 
  582.         }
  583.     
  584.         // If we're elligible to enter fullscreen
  585.         if ( ! mAtFullScreen && time > mLastActiveTime + mScrnSaverDelay ) {
  586.             SetFullScreen( true );
  587.             mMouseWillAwaken = true;
  588.         }
  589.     }
  590.  
  591.     
  592.     __setupPort    
  593.     
  594.     // Tell the PixPort we're about to start accessing it big time
  595.     port = mPort.BeginFrame();
  596.     if ( ! port )
  597.         port = mOSPort;
  598.  
  599.     if ( ! mCaptureMode ) {
  600.     
  601.         // Loop thru all the panes in the window and the the whitecap wave thingy
  602.         for ( i = 0; i < mNumWorlds; i++ ) {
  603.  
  604.             // Tell the world to update itself to the offscreen draw port
  605.             mWorld[ i ] -> Render( time, mPort, r );
  606.             
  607.             // If we're doing a capture playback, we have to make the dirty rect the entire pane
  608.             if ( mBltEntireWindow )
  609.                 r = *mWorld[ i ] -> PaneRect();
  610.             
  611.             // If we're drawing to a window, draw it right away
  612.             if ( mPort.IsFullscreen() )
  613.                 mPort.UnionDirtyRect( &r );
  614.             else 
  615.                 mPort.CopyBits( mOSPort, &r, &r );
  616.         }
  617.         
  618.         // See if we want to draw the title...
  619.         bool drawTitle;
  620.         if ( mAtFullScreen )
  621.             drawTitle = ( mShwT_Pref & 0x1 ) != 0;
  622.         else 
  623.             drawTitle = ( mShwT_Pref & 0x2 ) != 0;
  624.             
  625.         if ( drawTitle ) {
  626.  
  627.             // In the case we're using DrawSpocks, the cur port is the 'screen' port
  628.             #if MACAMP
  629.             if ( mPort.IsFullscreen() )
  630.                 ::GetPort( (GrafPtr*) &port );
  631.             #endif
  632.             
  633.             #if WINAMP
  634.             if ( ! mAtFullScreen )
  635.                 port = ::GetDC( mOSPort );
  636.             #endif
  637.             
  638.             // For each pane/world, draw the title string...        
  639.             for ( i = 0; i < mNumWorlds; i++ ) {
  640.                 
  641.                 mWorld[ i ] -> DrawConfigName( port );
  642.  
  643.                 // In mac land, we may need to tell the port to refresh the given rect on the screen
  644.                 #if EG_MAC        
  645.                 mPort.UnionDirtyRect( &mWorld[ i ] -> mTitleRect );
  646.                 #endif
  647.             }
  648.  
  649.             #if WINAMP
  650.             if ( ! mAtFullScreen )
  651.                 ::ReleaseDC( mOSPort, (HDC) port );
  652.             #endif
  653.         }
  654.             
  655.  
  656.         #if EG_MAC
  657.         
  658.         // If the option key is down, show the frame rate
  659.         unsigned char km[16];
  660.         ::GetKeys( (unsigned long*) km );
  661.         i = 58;    
  662.         if ( ((km[ i >> 3 ] >> (i & 7)) & 1) != 0 ) {
  663.         
  664.             // Calc frame rate, show the current computation for frames
  665.             if ( time - mFrameCountStart >= 1500 ) {
  666.                 mFramesPer10Secs = 10000 * mFrameCount / ( time - mFrameCountStart );
  667.                 mFrameRate.Assign( mFramesPer10Secs );
  668.                 mFrameRate.Insert( mFrameRate.length() - 1, ".", 1 );
  669.                 mFrameCountStart = time;
  670.                 mFrameCount = 0;
  671.             }
  672.             mFrameCount++;
  673.                 
  674.             Rect r = { 0, 0, 20, 40 };
  675.             ::EraseRect( &r );
  676.             ::MoveTo( 5, 15 );
  677.             ::DrawString( mFrameRate.getPasStr() );
  678.             if ( mPort.IsFullscreen() )
  679.                 mPort.UnionDirtyRect( &r );
  680.         }
  681.         
  682.         #endif
  683.     }
  684.     else  {
  685.         #if EG_MAC
  686.         ::MoveTo( 5, 20 );
  687.         ::DrawString( "\pCapturing..." );
  688.         #endif   
  689.     }
  690.  
  691.  
  692.     mPort.EndFrame();
  693.     
  694.     
  695.     __restorePort
  696. } 
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703.  
  704.  
  705.  
  706.  
  707. #define ___max( a, b ) (( (a) > (b) ) ? (a) : (b))
  708. #define ___maxSide( r ) (___max( r.right - r.left, r.bottom - r.top ))
  709.  
  710.  
  711. void WhiteCap::SetWinPort( GrafPtr inWin, const Rect* inRect ) {
  712.     Rect r;
  713.     
  714.     // mDoingSetPortWin == true is a signal that another thread is in SetWinPort()
  715.     if ( mDoingSetPortWin )
  716.         return;
  717.     mDoingSetPortWin = true;
  718.         
  719.     if ( inRect )
  720.         r = *inRect;
  721.     
  722.     // If an invalid win rect, fix it, you monkey!
  723.     if ( r.right - r.left < 20  || r.bottom - r.top < 20 || ! inRect ) {
  724.     
  725.         r.top                = mPrefs.GetPref( 'wTop' );
  726.         r.left                = mPrefs.GetPref( 'wLft' );
  727.         r.right                = mPrefs.GetPref( 'wRgt' );
  728.         r.bottom            = mPrefs.GetPref( 'wBot' );
  729.         
  730.         #if EG_MAC
  731.         // Invalidate the window if it's offscreen...
  732.         RgnHandle deskRgn = ::GetGrayRgn();
  733.         ::SectRect( &(*deskRgn) -> rgnBBox, &r, &r );
  734.         #endif
  735.     }
  736.  
  737.     // If no prefs avail (or an older version, use factory rect) or a bad win, hard code a size
  738.     if ( mPrefs.GetPref( 'Vers' ) != WHITECAP_COMPAT_VERSION || r.right - r.left < 20  || r.bottom - r.top < 20 ) {
  739.         r.top = 52;
  740.         r.left = 16;
  741.         r.right = 480;
  742.         r.bottom = 380; 
  743.     }
  744.  
  745.     long x = r.right - r.left;
  746.     long y = r.bottom - r.top;
  747.     
  748.     // Make width a double-word multiple
  749.     r.right -= x % 4;
  750.     
  751.             
  752.     #if EG_MAC
  753.     ::MoveWindow( inWin, r.left, r.top, true );
  754.     ::SizeWindow( inWin, x, y, true ); 
  755.     ::ShowWindow( inWin );
  756.     #else
  757.     RECT cr;
  758.     
  759.     // Resize the window and find the rgn we have to work with
  760.     ::MoveWindow( inWin, r.left, r.top, x, y, false );
  761.     ::GetClientRect( inWin, &cr );
  762.     x = cr.right - cr.left;
  763.     y = cr.bottom - cr.top;
  764.     #endif
  765.     
  766.     // The playpen for WhiteCap will be the entire window client rgn (what we'll give SetPort)
  767.     Rect portRect;
  768.     ::SetRect( &portRect, 0, 0, x, y );
  769.     SetPort( inWin, portRect, false );
  770.  
  771.     // Signal that this thread is done with SetPortWin()
  772.     mDoingSetPortWin = false;
  773. }
  774.  
  775.  
  776.  
  777.  
  778.  
  779. void WhiteCap::SetPort( GrafPtr inPort, const Rect& inRect, bool inFullScreen ) {
  780.     long x = inRect.right - inRect.left;
  781.     long y = inRect.bottom - inRect.top;
  782.  
  783.     mOSPort = inPort;
  784.     mPort.Init( x, y );
  785.     mDispRect = inRect;
  786.     mAtFullScreen = inFullScreen;
  787.     
  788.     
  789.     __setupPort
  790.     
  791.     
  792.     // If we're brand spankin new, show at least 1 config, you monkey
  793.     if ( mNumWorlds == 0 )
  794.         LoadConfig( mCurConfigNum, mLastRecordTime );
  795.     
  796.     __restorePort
  797.         
  798.     for ( int i = 0; i < mNumWorlds; i++ )
  799.         mWorld[ i ] -> ExpireSamples();
  800.         
  801.     ResizeWorlds();
  802. }
  803.  
  804.  
  805.  
  806.     
  807. void WhiteCap::ResizeWorlds() {
  808.     Rect r;
  809.     long i, j, bestLen, cutLen, best;
  810.  
  811.     
  812.     // Resize the panes in this window...
  813.     mWorld[ 0 ] -> SetPaneRect( mDispRect );
  814.     for ( i = 1; i < mNumWorlds; i++ ) {
  815.         
  816.         // Find the best world to cut in half
  817.         for ( bestLen = -1, j = 0; j < i; j++ ) {
  818.             cutLen = ___maxSide( (*mWorld[ j ] -> PaneRect()) );
  819.             if ( cutLen >= bestLen ) {
  820.                 bestLen = cutLen;
  821.                 best = j;
  822.             }
  823.         }
  824.         
  825.         // Change the pane rect of both the unplaced world and the world that's about to get cut in half
  826.         r = *(mWorld[ best ] -> PaneRect());
  827.         if ( r.right - r.left == bestLen ) {
  828.             r.right -= bestLen / 2;
  829.             mWorld[ best ] -> SetPaneRect( r );
  830.             OffsetRect( &r,  bestLen / 2,  0 );
  831.             mWorld[ i ] -> SetPaneRect( r ); }
  832.         else {
  833.             r.bottom -= bestLen / 2;
  834.             mWorld[ best ] -> SetPaneRect( r );
  835.             OffsetRect( &r,  0,  bestLen / 2 );
  836.             mWorld[ i ] -> SetPaneRect( r ); 
  837.         }                
  838.     }
  839. }
  840.  
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847.  
  848.  
  849. void WhiteCap::RefreshRect( const Rect& inUpdate ) {
  850.  
  851.     for ( int i = 0; i < mNumWorlds; i++ ) {
  852.         mWorld[ i ] -> RefreshRect( inUpdate );        
  853.     }
  854. }
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861.  
  862. void WhiteCap::LoadConfig( int inConfigNum, long inCurTime ) {
  863.     const CEgFileSpec* configSpec;
  864.     int i, exists;
  865.     long oldNumWorlds = mNumWorlds;
  866.     long transitionTime = EgOSUtils::Rnd( mTransitionLo * 1000, mTransitionHi * 1000 );
  867.         
  868.     mNumWorlds = 0;
  869.     mCurConfigNum = -1;
  870.     
  871.     // Don't bother initiating a config change if we're already running that config
  872.     if ( inConfigNum == mCurConfigNum )
  873.         return;
  874.         
  875.     // Fetch the spec for our config file or folder
  876.     configSpec = mConfigs.FetchSpec( inConfigNum );
  877.     
  878.     if ( configSpec ) {
  879.  
  880.          // If we have a folder or file...
  881.          exists = configSpec -> Exists();
  882.         if ( exists == 2 ) {
  883.             CEgFileSpec spec;
  884.             
  885.             bool startOver = true;
  886.             while ( EgOSUtils::GetNextFile( *configSpec, spec, startOver, false ) ) {
  887.                 if ( mNumWorlds >= oldNumWorlds )
  888.                     mWorld[ mNumWorlds ] = new WhiteCapWorld;
  889.                 mWorld[ mNumWorlds ] -> Init( &spec, inCurTime, transitionTime );
  890.                 mNumWorlds++;
  891.                 startOver = false;
  892.             }
  893.         }
  894.         
  895.         // Know what to put a check mark next to in the popup menu
  896.         mCurConfigNum = inConfigNum; 
  897.     }
  898.     
  899.     // If we're in capture, signal a config change...
  900.     if ( mCaptureMode ) {
  901.         UtilStr name;
  902.         if ( mConfigs.FetchSpecName( mCurConfigNum, name ) ) {
  903.             mDumpFile.PutByte( CAPTURE_CONFIG_CHANGE );
  904.             name.WriteTo( &mDumpFile );
  905.         }
  906.     }
  907.  
  908.     
  909.     // If it's only one config file or there's no spec specifed
  910.     if ( mNumWorlds == 0 ) {
  911.         mNumWorlds = 1;
  912.         if ( mNumWorlds > oldNumWorlds )
  913.             mWorld[ 0 ] = new WhiteCapWorld;
  914.         mWorld[ 0 ] -> Init( configSpec, inCurTime, transitionTime );
  915.     }
  916.     
  917.     for ( i = mNumWorlds; i < oldNumWorlds; i++ )
  918.         delete mWorld[ i ];
  919.  
  920.     // Set the time for when we load a random config automatically
  921.     mNextShapeChange = mLastRecordTime + mSlideShowInterval + transitionTime;
  922.     
  923.     // If the cursor was spun, init it back to the ptr
  924.     EgOSUtils::ResetCursor();
  925.  
  926.     // Make sure all WhiteCap's configs live happily inside the allowed draw area
  927.     ResizeWorlds();
  928.  
  929.     // Very annoying:  in Win32, the call to GetWindowRect() is returning garbage in ~WhiteCap(), so just 
  930.     // forget about saving the window position for now in windows :_(
  931.     #if EG_WIN
  932.     if ( ! mAtFullScreen )
  933.         GetWinRect( mWinRectHolder );
  934.     #endif
  935.  
  936.     if ( mAtFullScreen )
  937.         EgOSUtils::HideCursor();
  938. }
  939.  
  940.  
  941.  
  942.  
  943. void WhiteCap::BuildConfigList( CEgFileSpec& inPluginsFolder ) {
  944.     CEgFileSpec spec;
  945.     bool startOver = true;
  946.     int i;
  947.         
  948.     while ( EgOSUtils::GetNextFile( inPluginsFolder, spec, startOver, false ) ) {
  949.         mConfigs.AddCopy( spec );
  950.         startOver = false;
  951.     }
  952.     
  953.     startOver = true;
  954.     while ( EgOSUtils::GetNextFile( inPluginsFolder, spec, startOver, true ) ) {
  955.         mConfigs.AddCopy( spec );
  956.         startOver = false;
  957.     }
  958.     
  959.     // Always have a item called (Default) in the config list
  960.     UtilStr        def( "(Default)" );
  961.     spec.Assign( inPluginsFolder );
  962.     if ( ! mConfigs.Lookup( def ) ) {
  963.         spec.Rename( def );
  964.         mConfigs.AddCopy( spec );
  965.     }
  966.     mCurConfigNum = mConfigs.Lookup( def );
  967.  
  968.     // Build a random config 'play' list
  969.     mConfigPlayList.RemoveAll();
  970.     for ( i = mConfigs.Count(); i > 0; i-- ) 
  971.         mConfigPlayList.Add( i );
  972.     mConfigPlayList.Randomize();    
  973. }
  974.  
  975.  
  976.  
  977. CEgErr WhiteCap::DoDump( CEgIStream* inStream, long inNumSampleBins, long inFPS ) {
  978.     CEgFileSpec spec;
  979.     long captureCode, t, frame, minNextTime;
  980.     long frameDelay = 1000 / inFPS;
  981.     UtilStr str;
  982.     CEgIOFile oFile;
  983.     CEgErr err;
  984.     
  985.     frame = 0;
  986.     minNextTime = -1;
  987.     mHandleKeys = false;
  988.     mCaptureMode = false;
  989.     mBltEntireWindow = true;
  990.  
  991.  
  992.     spec.SetType( 'PICT' );
  993.     #if EG_MAC
  994.     PicHandle    pic;
  995.     GrafPtr        port;
  996.     
  997.     ::GetPort( &port );                
  998.     ::SetPort( mOSPort );
  999.     #endif
  1000.  
  1001.  
  1002.  
  1003.  
  1004.  
  1005.     captureCode = inStream -> GetByte();
  1006.     while ( inStream -> noErr() && err.noErr() && frame < 1050 ) {
  1007.     
  1008.         switch ( captureCode ) {
  1009.         
  1010.             case CAPTURE_SAMPLE:
  1011.             
  1012.                 // Mimic a legit sound sample being recorded
  1013.                 t = inStream -> GetLong();
  1014.                 inStream -> GetBlock( mSample, sizeof( float ) * NUM_SAMPLE_BINS );
  1015.                 if ( t < minNextTime )
  1016.                     break;
  1017.                 minNextTime += frameDelay;
  1018.                 RecordSample( t );
  1019.                 frame++;
  1020.  
  1021.                 // Generate the frame datapath
  1022.                 str.Assign( frame );
  1023.                 while ( str.length() < 4 )
  1024.                     str.Prepend( "0" );
  1025.                 str.Prepend(  "WC." );
  1026.                 spec.AssignPathName( str.getCStr() );
  1027.                 oFile.open( &spec );
  1028.                 err = oFile;
  1029.  
  1030.                 #if EG_MAC
  1031.                 
  1032.                 // Get the OS to script the frame
  1033.                 pic = ::OpenPicture( &mDispRect );
  1034.                 Draw();
  1035.                 ::ClosePicture();
  1036.                 oFile.CEgOStream::skip( 512 );
  1037.                 oFile.PutBlock( *pic, ::GetHandleSize( (Handle) pic ) );
  1038.                 oFile.close();
  1039.                 ::DrawPicture( pic, &mDispRect );
  1040.                 ::KillPicture( pic );
  1041.                 #endif
  1042.                 
  1043.                 break;
  1044.             
  1045.             case CAPTURE_CONFIG_CHANGE:
  1046.             
  1047.                 // Mimic something entered from the kybd...
  1048.                 mKeyBuf.ReadFrom( inStream );
  1049.                 mLastKeyTime = mLastRecordTime - 1000000;
  1050.                 break;
  1051.         }
  1052.         
  1053.         captureCode = inStream -> GetByte();
  1054.         EgOSUtils::SpinCursor();
  1055.     }
  1056.     
  1057.     #if EG_MAC
  1058.     ::SetPort( port );
  1059.     #endif
  1060.     
  1061.     // If any prefs were changed, don't save the changes
  1062.     mPrefs.SetNotDirty();
  1063.     
  1064.     return err;
  1065. }
  1066.  
  1067.